In [1]:
import tensorflow as tf
import pandas as pd
import numpy as np
df = pd.read_csv("C:/Users/Administrator/Desktop/Deep Learning/brstcan.csv")
df.head()
df.info()
In [ ]:
In [34]:
df.info()
In [97]:
df.head()
Out[97]:
In [98]:
df.isnull().values.any()
Out[98]:
In [279]:
df.isnull.sum()
In [100]:
df.describe()
Out[100]:
In [108]:
df.groupby('diagnosis').count()
Out[108]:
In [81]:
X_df=df.drop(columns=['diagnosis'])
Y_df = df['diagnosis']
X_df.shape, Y_df.shape
Out[81]:
In [60]:
X=np.array(X_df)
Y = np.array(Y_df)
In [70]:
from sklearn.preprocessing import OneHotEncoder
onehot = OneHotEncoder(sparse =False)
y= onehot.fit_transform.reshape(y.shape[0],1)
y.shape
In [109]:
df.drop([9.465],axis =0, inplace=True)
In [114]:
df.head()
df.groupby('diagnosis').count()
Out[114]:
In [160]:
df = pd.read_csv("C:/Users/Administrator/Desktop/Deep Learning/brstcanup.csv")
df.head()
Out[160]:
In [161]:
df.info()
df.isnull().values.any()
df.isnull.sum()
In [154]:
df.dropna(inplace=True)
df.isnull().values.any()
df.groupby('diagnosis').count()
Out[154]:
In [164]:
df.groupby('diagnosis').count()
df.info()
df.isnull().values.any()
Out[164]:
In [197]:
df = pd.read_csv("C:/Users/Administrator/Desktop/Deep Learning/brstcrup2.csv")
df.head()
Out[197]:
In [199]:
df.groupby('diagnosis').count()
Out[199]:
In [174]:
df.info()
df.isnull().values.any()
Out[174]:
In [176]:
df.describe()
Out[176]:
In [200]:
X_df=df.drop(columns=['diagnosis'])
Y_df = df['diagnosis']
X_df.shape, Y_df.shape
Out[200]:
In [201]:
X=np.array(X_df)
Y=np.array(Y_df)
from sklearn.preprocessing import OneHotEncoder
onehot = OneHotEncoder(sparse =False)
y= onehot.fit_transform(Y.reshape(Y.shape[0],1))
y.shape
Out[201]:
In [202]:
from sklearn.preprocessing import MinMaxScaler
scale = MinMaxScaler()
x = scale.fit_transform(X)
In [149]:
import tensorflow as tf
In [205]:
def model_keras(X):
model_k = tf.keras.models.Sequential()
model_k.add(tf.keras.layers.BatchNormalization(input_shape=(5,)))
model_k .add(tf.keras.layers.Dense(1000, activation ='relu'))
model_k .add(tf.keras.layers.Dropout(0,5))
model_k .add(tf.keras.layers. BatchNormalization())
model_k .add(tf.keras.layers. Dense(500, activation='relu'))
model_k .add(tf.keras.layers. BatchNormalization())
model_k .add(tf.keras.layers.Dropout(0,2))
model_k .add(tf.keras.layers. Dense(50, activation='relu'))
model_k .add(tf.keras.layers. BatchNormalization())
model_k .add(tf.keras.layers.Dropout(0,2))
model_k .add(tf.keras.layers. Dense(2))
model_k. add(tf.keras.layers.Activation('sigmoid'))
model_k. compile(tf.keras.optimizers.Adam(lr=0.0001), loss='binary_crossentropy', metrics=['accuracy'])
return model_k
In [206]:
model_keras = model_keras(X)
model_keras.fit(X,y,epochs = 5,verbose=1, validation_split=0.1)
Out[206]:
In [207]:
val_loss = model_keras.history.history['val_loss']
tra_loss = model_keras.history.history['loss']
val_acc = model_keras.history.history['val_acc']
tra_acc = model_keras.history.history['acc']
In [208]:
import matplotlib.pyplot as plt
plt.plot(val_acc)
plt.plot(tra_loss)
plt.xlabel('Epoch')
plt.ylabel('Accuracy')
plt.title(' Loss Curve')
plt.legend(['Validation Loss','Taining Loss'])
plt.show()
In [209]:
In [210]:
from sklearn.preprocessing import MinMaxScaler
test_df=pd.read_csv("C:/Users/Administrator/Desktop/Deep Learning/brstcrup2.csv")
test_df.head()
y_test= np.array(test_df['diagnosis'])
x_test= np.array(test_df.drop(columns='diagnosis'))
x_test.shape, y_test.shape
Out[210]:
In [245]:
X_test = MinMaxScaler().fit_transform(x_test)
y_test[0:10]
Out[245]:
In [251]:
y_test= OneHotEncoder(sparse=False).fit_transform(y_test.reshape(y_test.shape[0],1))
In [263]:
y_prd = model_keras.predict(X_test)
In [264]:
from sklearn.metrics import classification_report, confusion_matrix
y_prd = np.argmax(y_prd,1)
y_actual = np.argmax(y_test, 1)
print(classification_report(y_actual, y_prd))
print(confusion_matrix(y_actual, y_prd))
print(confusion_matrix(y_actual, y_prd))
In [266]:
print(confusion_matrix(y_actual, y_prd))
In [67]:
import glob
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
from skimage import transform
import cv2 as cv2
import seaborn as sns
In [ ]:
df = pd.read_csv("C:/Users/Administrator/Desktop/Deep Learning/indexcsc.csv")
df.head()
In [ ]:
df_count= df.groupby('id').count().sort_values(by = df.columns[0], ascending = False)
df_count.columns = ['urlcount']
df_count
In [ ]:
df_filter = df_count[(df_count['url'])>=50]
df_filter
In [1]:
import tensorflow_datasets as tfds
import tensorflow as tf
In [69]:
import numpy as np
from PIL import Image
im = Image.open("C:/Users/Administrator/Desktop/Deep Learning/aircraft/test/000010.jpg")
k=np.array(im)
np.savetxt('filename',k,delimiter=',')
In [10]:
import cv2
In [24]:
coun= 1
while coun<=10:
table = coun*2
coun = coun+1
print(table)
In [30]:
count = 1
while count<=10:
table = 2*count
count = count+1
print (table)
for i in range(10):
val = i+1
table = 2*val
print(table)
for i in range (14):
table =2*(i+1)
print(table)
In [45]:
marks = 90
if (marks==0):
print("fail")
elif(marks>85):
print('grade B')
else:
print('A')
In [50]:
def table(a):
for i in range(10):
table = a*(i+1)
print(table)
In [53]:
table(12)
In [65]:
img =imread("C:/Users/Administrator/Desktop/Deep Learning/aircraft/test/000010.jpg")
io.imshow(img)
In [20]:
import numpy as np
from skimage import io
img = io.imread("C:/Users/Administrator/Desktop/Deep Learning/aircraft/test/000010.jpg")
io.imshow(img)
# image show
Out[20]:
In [13]:
import numpy as np
from matplotlib import pyplot as plt
random_image = np.random.random([500,500])
plt.imshow(random_image,cmap='gray')
plt.colorbar();
In [21]:
from skimage import data
coins =data.coins()
print('Type', type(coins))
print('dtype',coins.dtype)
print('shap',coins.shape)
plt.imshow(coins,cmap='gray');
In [23]:
#Getting Image Resolution
from skimage import io
img = io.imread("C:/Users/Administrator/Desktop/Deep Learning/aircraft/test/000010.jpg")
img.shape
Out[23]:
In [27]:
#Getting Pixel Values
from skimage import io
import pandas as pd
img = io.imread("C:/Users/Administrator/Desktop/Deep Learning/aircraft/test/000010.jpg")
df = pd.DataFrame(img.flatten())
filepath = 'pixel_values1.xlsx'
df.to_excel(filepath, index=False)
print(df)
In [35]:
from skimage import data
from skimage import io
from skimage import color
from pylab import *
#read image
img = io.imread("C:/Users/Administrator/Desktop/Deep Learning/aircraft/test/000010.jpg")
#Convert to HSV
img_hsv = color.rgb2hsv(img)
#Convert back to RGB
img_rgb = color.hsv2rgb(img_hsv)
#Show both figures
figure(0)
io.imshow(img_hsv)
figure(1)
io.imshow(img_rgb)
Out[35]:
In [37]:
#Convert to XYZ
img_xyz = color.rgb2xyz(img)
#Convert back to RGB
img_rgb = color.xyz2rgb(img_xyz)
#Show both figures
figure(0)
io.imshow(img_xyz)
figure(1)
io.imshow(img_rgb)
Out[37]:
In [39]:
#Convert to LAB
img_lab = color.rgb2lab(img)
#Convert back to RGB
img_rgb = color.lab2rgb(img_lab)
#Show both figures
figure(0)
io.imshow(img_lab)
figure(1)
io.imshow(img_rgb)
Out[39]:
In [41]:
#Convert to YUV
img_yuv = color.rgb2yuv(img)
#Convert back to RGB
img_rgb = color.yuv2rgb(img_yuv)
#Show both figures
figure(0)
io.imshow(img_yuv)
figure(1)
io.imshow(img_rgb)
Out[41]:
In [43]:
#Convert to YIQ
img_yiq = color.rgb2yiq(img)
#Convert back to RGB
img_rgb = color.yiq2rgb(img_yiq)
#Show both figures
figure(0)
io.imshow(img_yiq)
figure(1)
io.imshow(img_rgb)
Out[43]:
In [45]:
#Convert to YPbPr
img_ypbpr= color.rgb2ypbpr(img)
#Convert back to RGB
img_rgb= color.ypbpr2rgb(img_ypbpr)
#Show both figures
figure(0)
io.imshow(img_ypbpr)
figure(1)
io.imshow(img_rgb)
Out[45]:
In [47]:
#Convert to YPbPr
img_ypbpr= color.rgb2ypbpr(img)
#Convert back to RGB
img_rgb= color.ypbpr2rgb(img_ypbpr)
io.imsave("aircraft_ypbpr.jpg", img_ypbpr)
In [52]:
from skimage import io
from skimage import draw
img = io.imread("C:/Users/Administrator/Desktop/Deep Learning/aircraft/test/000010.jpg")
x,y = draw.line(0,0,50,50)
img[x, y] = 0
io.imshow(img)
Out[52]:
In [77]:
from skimage import io
from skimage import data
img = io.imread("C:/Users/Administrator/Desktop/Deep Learning/aircraft/test/000010.jpg")
def rectangle(x, y, w, h):
rr,cc = [x, x + w, x + w, x], [y, y, y + h, y + h]
return (draw.polygon(rr, cc))
rr, cc = rectangle(10, 10, 500,500)
img[rr, cc] = 1
io.imshow(img)
In [81]:
from skimage import io
from skimage import data
img = io.imread("C:/Users/Administrator/Desktop/Deep Learning/aircraft/test/000010.jpg")
#Define circle coordinates and radius
x, y = draw.circle(50,50, 5)
#Draw circle
img[x, y] = 1
#Show image
io.imshow(img)
Out[81]:
In [85]:
from skimage import io
from skimage import data
img = io.imread("C:/Users/Administrator/Desktop/Deep Learning/aircraft/test/000010.jpg")
#Define Bezier curve coordinates
x, y = draw.bezier_curve(0,0, 50, 50, 9,10,10)
#Draw Bezier curve
img[x, y] = 1
#Show image
io.imshow(img)
Out[85]:
In [89]:
from skimage import io
from skimage import draw
#Load image
img = io.imread("C:/Users/Administrator/Desktop/Deep Learning/Tiger.jpg")
#Define Bezier curve coordinates
x, y = draw.bezier_curve(0,0, 50, 50, 90,120,10)
#Draw Bezier curve
img[x, y] = 1
#Show image
io.imshow(img)
Out[89]:
In [95]:
from skimage import exposure
from skimage import io
from pylab import *
img = io.imread("C:/Users/Administrator/Desktop/Deep Learning/Tiger.jpg")
gamma_corrected1 = exposure.adjust_gamma(img, 0.5)
gamma_corrected2 = exposure.adjust_gamma(img, 5)
gamma_corrected3 = exposure.adjust_gamma(img,2)
gamma_corrected4 = exposure.adjust_gamma(img, 0.3)
figure(0)
io.imshow(gamma_corrected1)
figure(1)
io.imshow(gamma_corrected2)
figure(2)
io.imshow(gamma_corrected3)
figure(3)
io.imshow(gamma_corrected4)
Out[95]:
In [98]:
from skimage import io
from skimage.transform import rotate
img = io.imread("C:/Users/Administrator/Desktop/Deep Learning/Tiger.jpg")
img_rotate = rotate(img,30)
io.imshow(img_rotate)
Out[98]:
In [100]:
#Import libraries
from skimage import io
from skimage import color
#Read image
img = io.imread("C:/Users/Administrator/Desktop/Deep Learning/Tiger.jpg")
#Convert to YPbPr
img_ypbpr= color.rgb2ypbpr(img)
#Convert back to RGB
img_rgb= color.ypbpr2rgb(img_ypbpr)
#Show both figures
figure(0)
io.imshow(img_ypbpr)
figure(1)
io.imshow(img_rgb)
Out[100]:
In [102]:
#Import libraries
from skimage import io
from skimage import color
from pylab import *
#Read image
img = io.imread("C:/Users/Administrator/Desktop/Deep Learning/Tiger.jpg")
#Convert to YPbPr
img_ypbpr= color.rgb2ypbpr(img)
#Convert back to RGB
img_rgb= color.ypbpr2rgb(img_ypbpr)
io.imsave("Tiger_ypbpr.jpg", img_ypbpr)
In [105]:
from skimage import io
from skimage.measure import compare_ssim as ssim
img_original = io.imread("C:/Users/Administrator/Desktop/Deep Learning/Tiger.jpg")
img_modified = io.imread('Tiger_ypbpr.jpg')
ssim_original = ssim(img_original, img_original, data_range=img_original.max() - img_original.min(), multichannel=True)
ssim_different = ssim(img_original, img_modified, data_range=img_modified.max() - img_modified.min(), multichannel=True)
print(ssim_original,ssim_different)
#SSIM takes three arguments. The first refers to the image;
#the second indicates the range of the pixels (the highest pixel color value less
#the lowest pixel color value). The third argument is multichannel.
#A True value means the image contains more than one channel,
#such as RGB. False means there is only one channel, such as grayscale.
In [116]:
#import required packages
import cv2
import numpy as np
#Read image
image = cv2.imread("C:/Users/Administrator/Desktop/Deep Learning/Tiger.jpg")
#Create a dummy image that stores different contrast and brightness
new_image = np.zeros(image.shape, image.dtype)
#Brightness and contrast parameters
contrast = 3.0
bright = 2
#Change the contrast and brightness
for y in range(image.shape[0]):
for x in range(image.shape[1]):
for c in range(image.shape[2]):
new_image[y,x,c] = np.clip(contrast*image[y,x,c] + bright, 0, 255)
figure(0)
io.imshow(image)
figure(1)
io.imshow(new_image)
Out[116]:
In [126]:
#import required packages
import cv2
import numpy as np
#Read image 1
img1 = cv2.imread("C:/Users/Administrator/Desktop/Deep Learning/Tiger.jpg")
#Read image 2
img2 = cv2.imread("C:/Users/Administrator/Desktop/Deep Learning/aircraft/test/000010.jpg")
#Define alpha and beta
alpha = 0.30
beta = 0.70
#Blend images
final_image = cv2.addWeighted(img1, alpha, img2, beta, 0.0)
#Show image
io.imshow(final_image)
In [129]:
#import required packages
import cv2
import numpy as np
#Read image
image = cv2.imread("C:/Users/Administrator/Desktop/Deep Learning/Tiger.jpg")
#Define font
font = cv2.FONT_HERSHEY_SIMPLEX
#Write on the image
cv2.putText(image, "I am not a Cat ", (230, 50), font, 0.8, (0, 255, 0), 2, cv2.LINE_AA)
io.imshow(image)
Out[129]:
In [131]:
#import required packages
import cv2
import numpy as np
#Read images for different blurring purposes
image_Original = cv2.imread("C:/Users/Administrator/Desktop/Deep Learning/Tiger.jpg")
image_MedianBlur = cv2.imread("C:/Users/Administrator/Desktop/Deep Learning/Tiger.jpg")
image_GaussianBlur = cv2.imread("C:/Users/Administrator/Desktop/Deep Learning/Tiger.jpg")
image_BilateralBlur = cv2.imread("C:/Users/Administrator/Desktop/Deep Learning/Tiger.jpg")
#Blur images
image_MedianBlur=cv2.medianBlur(image_MedianBlur,9)
image_GaussianBlur=cv2.GaussianBlur(image_GaussianBlur,(9,9),10)
image_BilateralBlur=cv2.bilateralFilter(image_BilateralBlur,9,100,75)
#Show images
figure(0)
io.imshow(image_Original)
figure(1)
io.imshow(image_MedianBlur)
figure(2)
io.imshow(image_GaussianBlur)
figure(3)
io.imshow(image_BilateralBlur)
Out[131]:
In [133]:
#DILATION CODE :
#Import package
import cv2
#Read image
image = cv2.imread("C:/Users/Administrator/Desktop/Deep Learning/Tiger.jpg")
#Define erosion size
s1 = 0
s2 = 10
s3 = 10
#Define erosion type
t1 = cv2.MORPH_RECT
t2 = cv2.MORPH_CROSS
t3 = cv2.MORPH_ELLIPSE
#Define and save the erosion template
tmp1 = cv2.getStructuringElement(t1, (2*s1 + 1, 2*s1+1), (s1, s1))
tmp2= cv2.getStructuringElement(t2, (2*s2 + 1, 2*s2+1), (s2, s2))
tmp3 = cv2.getStructuringElement(t3, (2*s3 + 1, 2*s3+1), (s3, s3))
#Apply the erosion template to the image and save in different variables
final1 = cv2.erode(image, tmp1)
final2 = cv2.erode(image, tmp2)
final3 = cv2.erode(image, tmp3)
#Show all the images with different erosions
figure(0)
io.imshow(final1)
figure(1)
io.imshow(final2)
figure(2)
io.imshow(final3)
#EROSION CODE :
#Import packages
import cv2
#Read images
image = cv2.imread("C:/Users/Administrator/Desktop/Deep Learning/Tiger.jpg")
#Define dilation size
d1 = 0
d2 = 10
d3 = 20
#Define dilation type
t1 = cv2.MORPH_RECT
t2 = cv2.MORPH_CROSS
t3 = cv2.MORPH_ELLIPSE
#Store the dilation templates
tmp1 = cv2.getStructuringElement(t1, (2*d1 + 1, 2*d1+1), (d1, d1))
tmp2 = cv2.getStructuringElement(t2, (2*d2 + 1, 2*d2+1), (d2, d2))
tmp3 = cv2.getStructuringElement(t3, (2*d3 + 1, 2*d3+1), (d3, d3))
#Apply dilation to the images
final1 = cv2.dilate(image, tmp1)
final2 = cv2.dilate(image, tmp2)
final3 = cv2.dilate(image, tmp3)
#Show the images
figure(0)
io.imshow(final1)
figure(1)
io.imshow(final2)
figure(2)
io.imshow(final3)
Out[133]:
In [141]:
#Import packages
import cv2
#Read image
image = cv2.imread("C:/Users/Administrator/Desktop/Deep Learning/Tiger.jpg")
#Define threshold types
"'
0 - Binary
1 - Binary Inverted
2 - Truncated
3 - Threshold To Zero
4 - Threshold To Zero Inverted
"'
#Apply different thresholds and save in different variables
_, img1 = cv2.threshold(image, 50, 255, 0 )
_, img2 = cv2.threshold(image, 50, 255, 1 )
_, img3 = cv2.threshold(image, 50, 255, 2 )
_, img4 = cv2.threshold(image, 50, 255, 3 )
_, img5 = cv2.threshold(image, 50, 255, 4 )
#Show the different threshold images
figure(0)
io.imshow(img1) #Prints Binary Image
figure(1)
io.imshow(img2) #Prints Binary Inverted Image
figure(2)
io.imshow(img3) #Prints Truncated Image
figure(3)
io.imshow(img4) #Prints Threshold to Zero Image
figure(4)
io.imshow(img5) #Prints Threshold to Zero Inverted Image
In [145]:
#Import packages
import cv2
#Read image
src = cv2.imread("C:/Users/Administrator/Desktop/Deep Learning/Tiger.jpg")
#Apply gaussian blur
cv2.GaussianBlur(src, (3, 3), 0)
#Convert image to grayscale
gray = cv2.cvtColor(src, cv2.COLOR_BGR2GRAY)
#Apply Sobel method to the grayscale image
grad_x = cv2.Sobel(gray, cv2.CV_16S, 1, 0, ksize=3, scale=1, delta=0, borderType=cv2.BORDER_DEFAULT) #Horizontal Sobel Derivation
grad_y = cv2.Sobel(gray, cv2.CV_16S, 0, 1, ksize=3, scale=1, delta=0, borderType=cv2.BORDER_DEFAULT) #Vertical Sobel Derivation
abs_grad_x = cv2.convertScaleAbs(grad_x)
abs_grad_y = cv2.convertScaleAbs(grad_y)
grad = cv2.addWeighted(abs_grad_x, 0.5, abs_grad_y, 0.5, 0) #Apply both
#Show the image
io.imshow(grad)#View the image
Out[145]:
In [147]:
#Import packages
import cv2
#Read image
src = cv2.imread("C:/Users/Administrator/Desktop/Deep Learning/Tiger.jpg")
#Convert to grayscale
src = cv2.cvtColor(src, cv2.COLOR_BGR2GRAY)
#Apply equalize histogram
src_eqlzd = cv2.equalizeHist(src) #Performs Histogram Equalization
#Show both images
figure(0)
io.imshow(src)
figure(1)
io.imshow(src_eqlzd)
figure(2)
io.imshow(src_eqlzd)
Out[147]:
In [ ]:
import cv2
import numpy as np
import matplotlib.pyplot as plt
def extract_sift_features(img):
sift_initialize = cv2.xfeatures2d.SIFT_create()
key_points, descriptors = sift_initialize.detectAndCompute(img, None)
return key_points, descriptors
def showing_sift_features(img1, img2, key_points):
return plt.imshow(cv2.drawKeypoints(img1, key_points, img2.copy()))
In [5]:
import cv2
import numpy as np
import matplotlib.pyplot as plt
from Sift_Opr import *
print('Make Sure that both the images are in the same folder')
x = input(' Enter the first Image Name')
Image1 = cv2.imread(x)
y = input(' Enter the second Image Name')
Image2 = cv2.imread(y)
Image1_gray = cv2.cvtColor(Image1, cv2.COLOR_BGR2GRAY)
Image2_gray = cv2.cvtColor(Image2, cv2.COLOR_BGR2GRAY)
Image1_key_points, Image1_descriptors = extract_sift_features(Image1_gray)
Image2_key_points, Image2_descriptors = extract_sift_features(Image2_gray)
print( 'Displaying SIFT Features')
showing_sift_features(Image1_gray, Image1, Image1_key_points);
norm = cv2.NORM_L2
bruteForce = cv2.BFMatcher(norm)
matches = bruteForce.match(Image1_descriptors, Image2_descriptors)
matches = sorted(matches, key = lambda match:match.distance)
matched_img = cv2.drawMatches(
Image1, Image1_key_points,
Image2, Image2_key_points,
matches[:100], Image2.copy())
plt.figure(figsize=(186,124))
plt.imshow(matched_img)
In [ ]:
In [4]:
import Sift_Operations.py